home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / x / volume6 / xldimage / patch3.2-2 < prev    next >
Encoding:
Text File  |  1990-02-27  |  19.5 KB  |  791 lines
  1. Path: uunet!samsung!brutus.cs.uiuc.edu!jarthur!elroy.jpl.nasa.gov!ames!sun-barr!newstop!sun!turnpike!argv
  2. From: argv%turnpike@Sun.COM (Dan Heller)
  3. Newsgroups: comp.sources.x
  4. Subject: v06i002: Xloadimage, Patch3, Part 02/02
  5. Message-ID: <132316@sun.Eng.Sun.COM>
  6. Date: 28 Feb 90 09:42:07 GMT
  7. Sender: news@sun.Eng.Sun.COM
  8. Lines: 780
  9. Approved: argv@sun.com
  10.  
  11. Submitted-by: Jim Frost <jimf@saber.com>
  12. Posting-number: Volume 6, Issue 2
  13. Archive-name: xldimage/patch3.2-2
  14. Patch-To: xldimage: Volume 5, Issue 27-28,30
  15.  
  16. This is part 2 of a 2 part patch to xloadimage to bring it from
  17. patchlevel 02 to patchlevel 03.
  18.  
  19. There are many bug fixes and improvements in patchlevel 03, including
  20. a new loader for GIF images.  This version should work on most X
  21. servers, including those with depths of odd values such as 2 or 4 (eg
  22. 386/ix servers).  See the README file for more information.
  23.  
  24. Part 1 contains a patch file which should be applied to a virgin
  25. patchlevel 02 source directory.  Save it in the file "patch.03" and
  26. apply via "patch < patch.03".
  27.  
  28. Part 2, which follows, contains a shar file with the new GIF loader
  29. and associated header files.  Save it in the file "patch.03.shar" and
  30. unpack it via "sh patch.03.shar".
  31.  
  32. If you do not have xloadimage or do not have it updated to patchlevel
  33. 02, you can get the original source (distributed at patchlevel 01) and
  34. the 02 patch from the comp.sources.x archives, or you can get the full
  35. distribution from expo.lcs.mit.edu in /contrib/xloadimage.1.03.tar.Z
  36. via anonymous ftp.  The original source and 02 patch are also on expo
  37. but have been moved to /oldcontrib.
  38.  
  39. Feel free to email any questions or comments.
  40.  
  41. Enjoy,
  42.  
  43. jim frost
  44. saber software
  45. jimf@saber.com
  46.  
  47. -- patch.03.shar: cut here --
  48. # This is a shell archive.  Remove anything before this line, then
  49. # unpack it by saving it in a file and typing "sh file".  (Files
  50. # unpacked will be owned by you and have default permissions.)
  51. #
  52. # This archive contains:
  53. # gif.c gif.h kljcpyrght.h
  54.  
  55. echo x - gif.c
  56. cat > "gif.c" << '//E*O*F gif.c//'
  57. /* gif.c:
  58.  *
  59.  * adapted from code by kirk johnson (tuna@athena.mit.edu).  most of this
  60.  * code is unchanged. -- jim frost 12.31.89
  61.  *
  62.  * gifin.c
  63.  * kirk johnson
  64.  * november 1989
  65.  *
  66.  * routines for reading GIF files
  67.  *
  68.  * Copyright 1989 Kirk L. Johnson (see the included file
  69.  * "kljcpyrght.h" for complete copyright information)
  70.  */
  71.  
  72. #include "xloadimage.h"
  73. #include "gif.h"
  74. #include "kljcpyrght.h"
  75.  
  76. /****
  77.  **
  78.  ** local #defines
  79.  **
  80.  ****/
  81.  
  82. #define PUSH_PIXEL(p)                                       \
  83. {                                                           \
  84.   if (pstk_idx == PSTK_SIZE)                                \
  85.     gifin_fatal("pixel stack overflow in PUSH_PIXEL()");    \
  86.   else                                                      \
  87.     pstk[pstk_idx++] = (p);                                 \
  88. }
  89.  
  90. /****
  91.  **
  92.  ** local variables
  93.  **
  94.  ****/
  95.  
  96. static int interlace_start[4]= { /* start line for interlacing */
  97.   0, 4, 2, 1
  98. };
  99.  
  100. static int interlace_rate[4]= { /* rate at which we accelerate vertically */
  101.   8, 8, 4, 2
  102. };
  103.  
  104. static BYTE file_open  = 0;     /* status flags */
  105. static BYTE image_open = 0;
  106.  
  107. static ZFILE *ins;              /* input stream */
  108.  
  109. static int  root_size;          /* root code size */
  110. static int  clr_code;           /* clear code */
  111. static int  eoi_code;           /* end of information code */
  112. static int  code_size;          /* current code size */
  113. static int  code_mask;          /* current code mask */
  114. static int  prev_code;          /* previous code */
  115.  
  116. /*
  117.  * NOTE: a long is assumed to be at least 32 bits wide
  118.  */
  119. static long work_data;          /* working bit buffer */
  120. static int  work_bits;          /* working bit count */
  121.  
  122. static BYTE buf[256];           /* byte buffer */
  123. static int  buf_cnt;            /* byte count */
  124. static int  buf_idx;            /* buffer index */
  125.  
  126. static int table_size;          /* string table size */
  127. static int prefix[STAB_SIZE];   /* string table : prefixes */
  128. static int extnsn[STAB_SIZE];   /* string table : extensions */
  129.  
  130. static BYTE pstk[PSTK_SIZE];    /* pixel stack */
  131. static int  pstk_idx;           /* pixel stack pointer */
  132.  
  133. /****
  134.  **
  135.  ** global variables
  136.  **
  137.  ****/
  138.  
  139. static int  gifin_rast_width;          /* raster width */
  140. static int  gifin_rast_height;         /* raster height */
  141. static BYTE gifin_g_cmap_flag;         /* global colormap flag */
  142. static int  gifin_g_pixel_bits;        /* bits per pixel, global colormap */
  143. static int  gifin_g_ncolors;           /* number of colors, global colormap */
  144. static BYTE gifin_g_cmap[3][256];      /* global colormap */
  145. static int  gifin_bg_color;            /* background color index */
  146. static int  gifin_color_bits;          /* bits of color resolution */
  147.  
  148. static int  gifin_img_left;            /* image position on raster */
  149. static int  gifin_img_top;             /* image position on raster */
  150. static int  gifin_img_width;           /* image width */
  151. static int  gifin_img_height;          /* image height */
  152. static BYTE gifin_l_cmap_flag;         /* local colormap flag */
  153. static int  gifin_l_pixel_bits;        /* bits per pixel, local colormap */
  154. static int  gifin_l_ncolors;           /* number of colors, local colormap */
  155. static BYTE gifin_l_cmap[3][256];      /* local colormap */
  156. static BYTE gifin_interlace_flag;      /* interlace image format flag */
  157.  
  158. /*
  159.  * open a GIF file, using s as the input stream
  160.  */
  161.  
  162. static int gifin_open_file(s)
  163.      ZFILE *s;
  164. {
  165.   /* make sure there isn't already a file open */
  166.   if (file_open)
  167.     return GIFIN_ERR_FAO;
  168.  
  169.   /* remember that we've got this file open */
  170.   file_open = 1;
  171.   ins       = s;
  172.  
  173.   /* check GIF signature */
  174.   if (zread(ins, buf, GIF_SIG_LEN) != GIF_SIG_LEN)
  175.     return GIFIN_ERR_EOF;
  176.  
  177.   buf[GIF_SIG_LEN] = '\0';
  178.   if (strcmp((char *) buf, GIF_SIG) != 0)
  179.     return GIFIN_ERR_BAD_SIG;
  180.  
  181.   /* read screen descriptor */
  182.   if (zread(ins, buf, GIF_SD_SIZE) != GIF_SD_SIZE)
  183.     return GIFIN_ERR_EOF;
  184.  
  185.   /* decode screen descriptor */
  186.   gifin_rast_width   = (buf[1] << 8) + buf[0];
  187.   gifin_rast_height  = (buf[3] << 8) + buf[2];
  188.   gifin_g_cmap_flag  = (buf[4] & 0x80) ? 1 : 0;
  189.   gifin_color_bits   = ((buf[4] & 0x70) >> 4) + 1;
  190.   gifin_g_pixel_bits = (buf[4] & 0x07) + 1;
  191.   gifin_bg_color     = buf[5];
  192.  
  193.   if (buf[6] != 0)
  194.     return GIFIN_ERR_BAD_SD;
  195.  
  196.   /* load global colormap */
  197.   if (gifin_g_cmap_flag)
  198.   {
  199.     gifin_g_ncolors = (1 << gifin_g_pixel_bits);
  200.  
  201.     if (gifin_load_cmap(gifin_g_cmap, gifin_g_ncolors) != GIFIN_SUCCESS)
  202.       return GIFIN_ERR_EOF;
  203.   }
  204.   else
  205.   {
  206.     gifin_g_ncolors = 0;
  207.   }
  208.  
  209.   /* done! */
  210.   return GIFIN_SUCCESS;
  211. }
  212.  
  213. /*
  214.  * open next GIF image in the input stream; returns GIFIN_SUCCESS if
  215.  * successful. if there are no more images, returns GIFIN_DONE. (might
  216.  * also return various GIFIN_ERR codes.)
  217.  */
  218.  
  219. static int gifin_open_image()
  220. {
  221.   int i;
  222.   int separator;
  223.  
  224.   /* make sure there's a file open */
  225.   if (!file_open)
  226.     return GIFIN_ERR_NFO;
  227.  
  228.   /* make sure there isn't already an image open */
  229.   if (image_open)
  230.     return GIFIN_ERR_IAO;
  231.  
  232.   /* remember that we've got this image open */
  233.   image_open = 1;
  234.  
  235.   /* skip over any extension blocks */
  236.   do
  237.   {
  238.     separator = zgetc(ins);
  239.     if (separator == GIF_EXTENSION)
  240.     {
  241.       if (gifin_skip_extension() != GIFIN_SUCCESS)
  242.         return GIFIN_ERR_EOF;
  243.     }
  244.   }
  245.   while (separator == GIF_EXTENSION);
  246.  
  247.   /* check for end of file marker */
  248.   if (separator == GIF_TERMINATOR)
  249.     return GIFIN_DONE;
  250.  
  251.   /* make sure we've got an image separator */
  252.   if (separator != GIF_SEPARATOR)
  253.     return GIFIN_ERR_BAD_SEP;
  254.  
  255.   /* read image descriptor */
  256.   if (zread(ins, buf, GIF_ID_SIZE) != GIF_ID_SIZE)
  257.     return GIFIN_ERR_EOF;
  258.  
  259.   /* decode image descriptor */
  260.   gifin_img_left       = (buf[1] << 8) + buf[0];
  261.   gifin_img_top        = (buf[3] << 8) + buf[2];
  262.   gifin_img_width      = (buf[5] << 8) + buf[4];
  263.   gifin_img_height     = (buf[7] << 8) + buf[6];
  264.   gifin_l_cmap_flag    = (buf[8] & 0x80) ? 1 : 0;
  265.   gifin_interlace_flag = (buf[8] & 0x40) ? 1 : 0;
  266.   gifin_l_pixel_bits   = (buf[8] & 0x07) + 1;
  267.  
  268.   /* load local colormap */
  269.   if (gifin_l_cmap_flag)
  270.   {
  271.     gifin_l_ncolors = (1 << gifin_l_pixel_bits);
  272.  
  273.     if (gifin_load_cmap(gifin_l_cmap, gifin_l_ncolors) != GIFIN_SUCCESS)
  274.       return GIFIN_ERR_EOF;
  275.   }
  276.   else
  277.   {
  278.     gifin_l_ncolors = 0;
  279.   }
  280.  
  281.   /* initialize raster data stream decoder */
  282.   root_size = zgetc(ins);
  283.   clr_code  = 1 << root_size;
  284.   eoi_code  = clr_code + 1;
  285.   code_size = root_size + 1;
  286.   code_mask = (1 << code_size) - 1;
  287.   work_bits = 0;
  288.   work_data = 0;
  289.   buf_cnt   = 0;
  290.   buf_idx   = 0;
  291.  
  292.   /* initialize string table */
  293.   for (i=0; i<STAB_SIZE; i++)
  294.   {
  295.     prefix[i] = NULL_CODE;
  296.     extnsn[i] = i;
  297.   }
  298.  
  299.   /* initialize pixel stack */
  300.   pstk_idx = 0;
  301.  
  302.   /* done! */
  303.   return GIFIN_SUCCESS;
  304. }
  305.  
  306. /*
  307.  * try to read next pixel from the raster, return result in *pel
  308.  */
  309.  
  310. static int gifin_get_pixel(pel)
  311.      int *pel;
  312. {
  313.   int  code;
  314.   int  first;
  315.   int  place;
  316.  
  317.   /* decode until there are some pixels on the pixel stack */
  318.   while (pstk_idx == 0)
  319.   {
  320.     /* load bytes until we have enough bits for another code */
  321.     while (work_bits < code_size)
  322.     {
  323.       if (buf_idx == buf_cnt)
  324.       {
  325.         /* read a new data block */
  326.         if (gifin_read_data_block() != GIFIN_SUCCESS)
  327.           return GIFIN_ERR_EOF;
  328.  
  329.         if (buf_cnt == 0)
  330.           return GIFIN_ERR_EOD;
  331.       }
  332.  
  333.       work_data |= ((long) buf[buf_idx++]) << work_bits;
  334.       work_bits += 8;
  335.     }
  336.  
  337.     /* get the next code */
  338.     code        = work_data & code_mask;
  339.     work_data >>= code_size;
  340.     work_bits  -= code_size;
  341.  
  342.     /* interpret the code */
  343.     if (code == clr_code)
  344.     {
  345.       /* reset decoder stream */
  346.       code_size  = root_size + 1;
  347.       code_mask  = (1 << code_size) - 1;
  348.       prev_code  = NULL_CODE;
  349.       table_size = eoi_code + 1;
  350.     }
  351.     else if (code == eoi_code)
  352.     {
  353.       /* Ooops! no more pixels */
  354.       return GIFIN_ERR_EOF;
  355.     }
  356.     else if (prev_code == NULL_CODE)
  357.     {
  358.       gifin_push_string(code);
  359.       prev_code = code;
  360.     }
  361.     else
  362.     {
  363.       if (code < table_size)
  364.       {
  365.         first = gifin_push_string(code);
  366.       }
  367.       else
  368.       {
  369.         place = pstk_idx;
  370.         PUSH_PIXEL(NULL_CODE);
  371.         first = gifin_push_string(prev_code);
  372.         pstk[place] = first;
  373.       }
  374.  
  375.       gifin_add_string(prev_code, first);
  376.       prev_code = code;
  377.     }
  378.   }
  379.  
  380.   /* pop a pixel off the pixel stack */
  381.   *pel = (int) pstk[--pstk_idx];
  382.  
  383.   /* done! */
  384.   return GIFIN_SUCCESS;
  385. }
  386.  
  387. /*
  388.  * close an open GIF image
  389.  */
  390.  
  391. static int gifin_close_image()
  392. {
  393.   /* make sure there's an image open */
  394.   if (!image_open)
  395.     return GIFIN_ERR_NIO;
  396.  
  397.   /* skip any remaining raster data */
  398.   do
  399.   {
  400.     if (gifin_read_data_block() != GIFIN_SUCCESS)
  401.       return GIFIN_ERR_EOF;
  402.   }
  403.   while (buf_cnt > 0);
  404.  
  405.   /* mark image as closed */
  406.   image_open = 0;
  407.  
  408.   /* done! */
  409.   return GIFIN_SUCCESS;
  410. }
  411.  
  412. /*
  413.  * close an open GIF file
  414.  */
  415.  
  416. static int gifin_close_file()
  417. {
  418.   /* make sure there's a file open */
  419.   if (!file_open)
  420.     return GIFIN_ERR_NFO;
  421.  
  422.   /* mark file (and image) as closed */
  423.   file_open  = 0;
  424.   image_open = 0;
  425.  
  426.   /* done! */
  427.   return GIFIN_SUCCESS;
  428. }
  429.  
  430. /*
  431.  * load a colormap from the input stream
  432.  */
  433.  
  434. static int gifin_load_cmap(cmap, ncolors)
  435.      BYTE cmap[3][256];
  436.      int  ncolors;
  437. {
  438.   int i;
  439.  
  440.   for (i=0; i<ncolors; i++)
  441.   {
  442.     if (zread(ins, buf, 3) != 3)
  443.       return GIFIN_ERR_EOF;
  444.     
  445.     cmap[GIF_RED][i] = buf[GIF_RED];
  446.     cmap[GIF_GRN][i] = buf[GIF_GRN];
  447.     cmap[GIF_BLU][i] = buf[GIF_BLU];
  448.   }
  449.  
  450.   /* done! */
  451.   return GIFIN_SUCCESS;
  452. }
  453.  
  454. /*
  455.  * skip an extension block in the input stream
  456.  */
  457.  
  458. static int gifin_skip_extension()
  459. {
  460.   int function;
  461.  
  462.   /* get the extension function byte */
  463.   function = zgetc(ins);
  464.  
  465.   /* skip any remaining raster data */
  466.   do
  467.   {
  468.     if (gifin_read_data_block() != GIFIN_SUCCESS)
  469.       return GIFIN_ERR_EOF;
  470.   }
  471.   while (buf_cnt > 0);
  472.  
  473.   /* done! */
  474.   return GIFIN_SUCCESS;
  475. }
  476.  
  477. /*
  478.  * read a new data block from the input stream
  479.  */
  480.  
  481. static int gifin_read_data_block()
  482. {
  483.   /* read the data block header */
  484.   buf_cnt = zgetc(ins);
  485.  
  486.   /* read the data block body */
  487.   if (zread(ins, buf, buf_cnt) != buf_cnt)
  488.     return GIFIN_ERR_EOF;
  489.  
  490.   buf_idx = 0;
  491.  
  492.   /* done! */
  493.   return GIFIN_SUCCESS;
  494. }
  495.  
  496. /*
  497.  * push a string (denoted by a code) onto the pixel stack
  498.  * (returns the code of the first pixel in the string)
  499.  */
  500.  
  501. static int gifin_push_string(code)
  502.      int code;
  503. {
  504.   int rslt;
  505.  
  506.   while (prefix[code] != NULL_CODE)
  507.   {
  508.     PUSH_PIXEL(extnsn[code]);
  509.     code = prefix[code];
  510.   }
  511.  
  512.   PUSH_PIXEL(extnsn[code]);
  513.   rslt = extnsn[code];
  514.  
  515.   return rslt;
  516. }
  517.  
  518. /*
  519.  * add a new string to the string table
  520.  */
  521.  
  522. static gifin_add_string(p, e)
  523.      int p;
  524.      int e;
  525. {
  526.   prefix[table_size] = p;
  527.   extnsn[table_size] = e;
  528.  
  529.   if ((table_size == code_mask) && (code_size < 12))
  530.   {
  531.     code_size += 1;
  532.     code_mask  = (1 << code_size) - 1;
  533.   }
  534.  
  535.   table_size += 1;
  536. }
  537.  
  538. /*
  539.  * semi-graceful fatal error mechanism
  540.  */
  541.  
  542. static gifin_fatal(msg)
  543.      char *msg;
  544. {
  545.   printf("Error reading GIF file: %s\n", msg);
  546.   exit(0);
  547. }
  548.  
  549. /* these are the routines added for interfacing to xloadimage
  550.  */
  551.  
  552. /* tell someone what the image we're loading is.  this could be a little more
  553.  * descriptive but I don't care
  554.  */
  555.  
  556. static void tellAboutImage(name)
  557.      char *name;
  558. {
  559.   printf("%s is a %dx%d %sGIF image with %d colors\n", name,
  560.      gifin_img_width, gifin_img_height,
  561.      (gifin_interlace_flag ? "interlaced " : ""),
  562.      (gifin_l_cmap_flag ? gifin_l_ncolors : gifin_g_ncolors));
  563. }
  564.  
  565. Image *gifLoad(fullname, name, verbose)
  566.      char         *fullname, *name;
  567.      unsigned int  verbose;
  568. { ZFILE *zf;
  569.   Image *image;
  570.   int    x, y, pixel, pass, yrate, scanlen;
  571.   byte  *pixptr, *pixline;
  572.  
  573.   if (! (zf= zopen(fullname)))
  574.     return(NULL);
  575.   if ((gifin_open_file(zf) != GIFIN_SUCCESS) || /* read GIF header */
  576.       (gifin_open_image() != GIFIN_SUCCESS)) {  /* read image header */
  577.     gifin_close_file();
  578.     zclose(zf);
  579.     return(NULL);
  580.   }
  581.   if (verbose)
  582.     tellAboutImage(name);
  583.  
  584.   image= newRGBImage(gifin_img_width, gifin_img_height, (gifin_l_cmap_flag ?
  585.                              gifin_l_pixel_bits :
  586.                              gifin_g_pixel_bits));
  587.   for (x= 0; x < gifin_g_ncolors; x++) {
  588.     image->rgb.red[x]= gifin_g_cmap[GIF_RED][x] << 8;
  589.     image->rgb.green[x]= gifin_g_cmap[GIF_GRN][x] << 8;
  590.     image->rgb.blue[x]= gifin_g_cmap[GIF_BLU][x] << 8;
  591.   }
  592.   image->rgb.used= gifin_g_ncolors;
  593.  
  594.   /* if image has a local colormap, override global colormap
  595.    */
  596.  
  597.   if (gifin_l_cmap_flag) {
  598.     for (x= 0; x < image->rgb.size; x++) {
  599.       image->rgb.red[x]= gifin_g_cmap[GIF_RED][x] << 8;
  600.       image->rgb.green[x]= gifin_g_cmap[GIF_GRN][x] << 8;
  601.       image->rgb.blue[x]= gifin_g_cmap[GIF_BLU][x] << 8;
  602.     }
  603.     image->rgb.used= gifin_l_ncolors;
  604.   }
  605.  
  606.   /* interlaced image -- futz with the vertical trace.  i wish i knew what
  607.    * kind of drugs the GIF people were on when they decided that they
  608.    * needed to support interlacing.
  609.    */
  610.  
  611.   if (gifin_interlace_flag) {
  612.     scanlen= image->height * image->pixlen;
  613.  
  614.     /* interlacing takes four passes to read, each starting at a different
  615.      * vertical point.
  616.      */
  617.  
  618.     for (pass= 0; pass < 4; pass++) {
  619.       y= interlace_start[pass];
  620.       scanlen= image->width * image->pixlen * interlace_rate[pass];
  621.       pixline= image->data + (y * image->width * image->pixlen);
  622.       while (y < gifin_img_height) {
  623.     pixptr= pixline;
  624.     for (x= 0; x < gifin_img_width; x++) {
  625.       if (gifin_get_pixel(&pixel) != GIFIN_SUCCESS) {
  626.         printf("%s: Short read within image data\n", fullname);
  627.         exit(0);
  628.       }
  629.       valToMem(pixel, pixptr, image->pixlen);
  630.       pixptr += image->pixlen;
  631.     }
  632.     y += interlace_rate[pass];
  633.     pixline += scanlen;
  634.       }
  635.     }
  636.   }
  637.  
  638.   /* not an interlaced image, just read in sequentially
  639.    */
  640.  
  641.   else {
  642.     pixptr= image->data;
  643.     for (y= 0; y < gifin_img_height; y++)
  644.       for (x= 0; x < gifin_img_width; x++) {
  645.     if (gifin_get_pixel(&pixel) != GIFIN_SUCCESS) {
  646.       printf("%s: Short read within image data\n", fullname);
  647.       exit(0);
  648.     }
  649.     valToMem(pixel, pixptr, image->pixlen);
  650.     pixptr += image->pixlen;
  651.       }
  652.   }
  653.   gifin_close_file();
  654.   zclose(zf);
  655.   image->title= dupString(name);
  656.   return(image);
  657. }
  658.  
  659. unsigned int gifIdent(fullname, name)
  660.      char *fullname, *name;
  661. { ZFILE        *zf;
  662.   unsigned int  ret;
  663.  
  664.   if (! (zf= zopen(fullname)))
  665.     return(0);
  666.   if ((gifin_open_file(zf) == GIFIN_SUCCESS) &&
  667.       (gifin_open_image() == GIFIN_SUCCESS)) {
  668.     tellAboutImage(name);
  669.     ret= 1;
  670.   }
  671.   else
  672.     ret= 0;
  673.   gifin_close_file();
  674.   zclose(zf);
  675.   return(ret);
  676. }
  677. //E*O*F gif.c//
  678.  
  679. echo x - gif.h
  680. cat > "gif.h" << '//E*O*F gif.h//'
  681. /* gif.h:
  682.  *
  683.  * gifin.h
  684.  * kirk johnson
  685.  * november 1989
  686.  * external interface to gifin.c
  687.  *
  688.  * Copyright 1989 Kirk L. Johnson (see the included file
  689.  * "kljcpyrght.h" for complete copyright information)
  690.  */
  691.  
  692. /*
  693.  * gifin return codes
  694.  */
  695. #define GIFIN_SUCCESS       0   /* success */
  696. #define GIFIN_DONE          1   /* no more images */
  697.  
  698. #define GIFIN_ERR_BAD_SD   -1   /* bad screen descriptor */
  699. #define GIFIN_ERR_BAD_SEP  -2   /* bad image separator */
  700. #define GIFIN_ERR_BAD_SIG  -3   /* bad signature */
  701. #define GIFIN_ERR_EOD      -4   /* unexpected end of raster data */
  702. #define GIFIN_ERR_EOF      -5   /* unexpected end of input stream */
  703. #define GIFIN_ERR_FAO      -6   /* file already open */
  704. #define GIFIN_ERR_IAO      -7   /* image already open */
  705. #define GIFIN_ERR_NFO      -8   /* no file open */
  706. #define GIFIN_ERR_NIO      -9   /* no image open */
  707.  
  708. /*
  709.  * colormap indices 
  710.  */
  711.  
  712. #define GIF_RED  0
  713. #define GIF_GRN  1
  714. #define GIF_BLU  2
  715.  
  716. /*
  717.  * typedef BYTE for convenience
  718.  */
  719.  
  720. typedef unsigned char BYTE;
  721.  
  722. static int gifin_open_file();
  723. static int gifin_open_image();
  724. static int gifin_get_pixel();
  725. static int gifin_close_image();
  726. static int gifin_close_file();
  727. static int gifin_load_cmap();
  728. static int gifin_skip_extension();
  729. static int gifin_read_data_block();
  730. static int gifin_push_string();
  731. static int gifin_add_string();
  732. static int gifin_fatal();
  733.  
  734. /* #defines, typedefs, and such
  735.  */
  736.  
  737. #define GIF_SIG      "GIF87a"
  738. #define GIF_SIG_LEN  6          /* GIF signature length */
  739. #define GIF_SD_SIZE  7          /* GIF screen descriptor size */
  740. #define GIF_ID_SIZE  9          /* GIF image descriptor size */
  741.  
  742. #define GIF_SEPARATOR   ','     /* GIF image separator */
  743. #define GIF_EXTENSION   '!'     /* GIF extension block marker */
  744. #define GIF_TERMINATOR  ';'     /* GIF terminator */
  745.  
  746. #define STAB_SIZE  4096         /* string table size */
  747. #define PSTK_SIZE  1024         /* pixel stack size */
  748.  
  749. #define NULL_CODE  -1           /* string table null code */
  750. //E*O*F gif.h//
  751.  
  752. echo x - kljcpyrght.h
  753. cat > "kljcpyrght.h" << '//E*O*F kljcpyrght.h//'
  754. #ifndef _KLJ_COPYRIGHT_
  755.  
  756. /****
  757.   Copyright 1989 Kirk L. Johnson
  758.  
  759.   Permission to use, copy, modify, distribute, and sell this
  760.   software and its documentation for any purpose is hereby granted
  761.   without fee, provided that the above copyright notice appear in
  762.   all copies and that both that copyright notice and this
  763.   permission notice appear in supporting documentation. The
  764.   author makes no representations about the suitability of this
  765.   software for any purpose. It is provided "as is" without express
  766.   or implied warranty.
  767.  
  768.   THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  769.   INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS,
  770.   IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, INDIRECT
  771.   OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  772.   LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
  773.   NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  774.   CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  775. ****/
  776.  
  777. static char *KLJCopyright = "Copyright 1989 Kirk L. Johnson";
  778. #define _KLJ_COPYRIGHT_
  779. #endif
  780. //E*O*F kljcpyrght.h//
  781.  
  782. exit 0
  783.  
  784. dan
  785. -----------------------------------------------------------
  786.             O'Reilly && Associates
  787.         argv@sun.com / argv@ora.com
  788.        632 Petaluma Ave, Sebastopol, CA 95472 
  789.      800-338-NUTS, in CA: 800-533-NUTS, FAX 707-829-0104
  790.     Opinions expressed reflect those of the author only.
  791.